
#ifndef __MY_CONFIG__
#define __MY_CONFIG__
#include "tool.hpp"
#include <mutex>
#define CONFIG_FILE "./Val.conf"

//使用单例模式读取配置文件，因为因为这里读取次数不需要太多，然后就可以使用懒汉模式，使用时调用
//读文件的信息通过返序列化形成json格式，然后通过函数接口返回所需要的数值


namespace Cloud_up
{

    class Config
    {
    private: 
        static Config *_instance;
        static std::mutex _mutex;
        Config() 
        {
            ReadConfig();
        }
        Config(const Config&);
        Config &operator=(const Config&);


    private:
        int _hot_time;             // 热点时间
        int _server_port;          // 服务器监听端口
        std::string _server_ip;    // 服务器IP
        std::string _url_prefix;   // 下载的url前缀路径
        std::string _arc_suffix;   // 压缩包后缀名称
        std::string _pack_dir;     // 压缩包存放目录
        std::string _back_dir;     // 备份包存放目录
        std::string _manager_file; // 数据信息存放文件

    public:
        // 读取.conf配置文件
        bool ReadConfig()
        {
            Filetool ft(CONFIG_FILE); //
            std::string str;
            if (ft.GetContent(&str) == false) //读CONFIG_FILE数据到str
            {
                std::cout << "GetContent() faile" << std::endl;
                return false;
            }

            Json::Value val;
            if (json_tool::UnSerialize(str, &val) == false) //反序列化 json化
            {
                std::cout << "UnSerialize() faile" << std::endl;
                return false;
            }
            
            //键对值赋值
            _hot_time = val["hot_time"].asInt();
            _server_port = val["server_port"].asInt();
            _server_ip = val["server_ip"].asString();
            _url_prefix = val["url_prefix"].asString();
            _arc_suffix = val["arc_suffix"].asString();
            _pack_dir = val["pack_dir"].asString();
            _back_dir = val["back_dir"].asString();
            _manager_file = val["manager_file"].asString();

            return true;
        }

        //获取信息函数
        // 热点时间
        int GetHotTime() { return _hot_time; }
        // 服务器监听端口
        int GetServerPort() { return _server_port; }
        // 服务器IP
        std::string GetServerIp() { return _server_ip; }
        // 下载的url前缀路径
        std::string GetUrlPrefix() { return _url_prefix; }
        // 压缩包后缀名称
        std::string GetArcSuffix() { return _arc_suffix; }
        // 压缩包存放目录
        std::string GetPackDir() { return _pack_dir; }
        // 备份包存放目录
        std::string GetBackDir() { return _back_dir; }
        // 数据信息存放文件
        std::string GetManagerFile() { return _manager_file; }



// 使用懒汉构造 因为每次解压或者存文件的时候才会调用


//单例模式
//构造需要封死
//懒汉：系统运行时不会实例，使用时实例，
//缺点:并没有线程安全，需要同步操作，_mutex来确保原子操作，调用时才会加载

//饿汉：(单例对象类加载前已经创建好了) 保证线程安全 
//缺点：系统运行则实例，资源会有些浪费
//实例化对象确保唯一性

    
    public:
        static Config *GetInstance()
        {
            if (_instance == NULL) //先判断再枷锁
            {
                _mutex.lock();
                if (_instance == NULL)
                {
                    _instance = new Config();
                }
                _mutex.unlock();
            }
            return _instance;
        }
    };
    Config *Config::_instance = NULL;
    std::mutex Config::_mutex;

}

#endif